home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
EuroCD 3
/
EuroCD 3.iso
/
Programming
/
vbcc
/
type_expr.c
< prev
next >
Wrap
C/C++ Source or Header
|
1998-06-24
|
50KB
|
1,191 lines
/* $VER: vbcc (type_expr.c) V0.4 */
#include "vbc.h"
static char FILE_[]=__FILE__;
int alg_opt(np),type_expression2(np);
int test_assignment(struct Typ *,np);
void make_cexpr(np);
int dontopt;
void insert_const(np p)
/* Spezialfall fuer np */
{
if(!p||!p->ntyp) ierror(0);
insert_const2(&p->val,p->ntyp->flags);
}
int const_typ(struct Typ *p)
/* Testet, ob Typ konstant ist oder konstante Elemente enthaelt */
{
int i;struct struct_declaration *sd;
if(p->flags&CONST) return(1);
if(p->flags==STRUCT||p->flags==UNION)
for(i=0;i<p->exact->count;i++)
if(const_typ((*p->exact->sl)[i].styp)) return(1);
return(0);
}
struct Typ *arith_typ(struct Typ *a,struct Typ *b)
/* Erzeugt Typ fuer arithmetische Umwandlung von zwei Operanden */
{
int ta,tb;struct Typ *new;
new=mymalloc(TYPS);
new->next=0;
ta=a->flags&NU;tb=b->flags&NU;
if(ta==DOUBLE||tb==DOUBLE){new->flags=DOUBLE;return(new);}
if(ta==FLOAT||tb==FLOAT){new->flags=FLOAT;return(new);}
ta=int_erw(ta);tb=int_erw(tb);
if(ta==(UNSIGNED|LONG)||tb==(UNSIGNED|LONG)){new->flags=UNSIGNED|LONG;return(new);}
if((ta==LONG&&tb==(UNSIGNED|INT))||(ta==(UNSIGNED|INT)&&tb==LONG)){
if(UINT_MAX<=LONG_MAX) new->flags=LONG; else new->flags=UNSIGNED|LONG;
return(new);
}
if(ta==LONG||tb==LONG){new->flags=LONG;return(new);}
if(ta==(UNSIGNED|INT)||tb==(UNSIGNED|INT)){new->flags=UNSIGNED|INT;return(new);}
new->flags=INT;
return(new);
}
int int_erw(int t)
/* Fuehrt Integer_Erweiterung eines Typen durch */
{
if((t&NQ)>SHORT) return(t);
if((t&NU)==CHAR&&SCHAR_MAX<=INT_MAX) return(INT);
if((t&NU)==SHORT&&SHRT_MAX<=INT_MAX) return(INT);
if((t&NU)==(UNSIGNED|CHAR)&&UCHAR_MAX<=INT_MAX) return(INT);
if((t&NU)==(UNSIGNED|SHORT)&&USHRT_MAX<=INT_MAX) return(INT);
return(UNSIGNED|INT);
}
int type_expression(np p)
/* Art Frontend fuer type_expression2(). Setzt dontopt auf 0 */
{
dontopt=0;
return(type_expression2(p));
}
int type_expression2(np p)
/* Erzeugt Typ-Strukturen fuer jeden Knoten des Baumes und */
/* liefert eins zurueck, wenn der Baum ok ist, sonst 0 */
/* Die Berechnung von Konstanten und andere Vereinfachungen */
/* sollten vielleicht in eigene Funktion kommen */
{
int ok,f=p->flags,mopt=dontopt;
if(!p){ierror(0);return(1);}
/* if(p->ntyp) printf("Warnung: ntyp!=0\n");*/
p->lvalue=0;
p->sidefx=0;
ok=1;
if(f==CALL&&p->left->flags==IDENTIFIER&&!find_var(p->left->identifier,0)){
/* implizite Deklaration bei Aufruf einer Funktion */
struct struct_declaration *sd;struct Typ *t;
error(161,p->left->identifier);
sd=mymalloc(sizeof(*sd));
sd->count=0;
t=mymalloc(TYPS);
t->flags=FUNKT;
t->exact=add_sd(sd);
t->next=mymalloc(TYPS);
t->next->next=0;
t->next->flags=INT;
add_var(p->left->identifier,t,EXTERN,0);
}
dontopt=0;
if(f==ADDRESS&&p->left->flags==IDENTIFIER) {p->left->flags|=256;/*puts("&const");*/}
if(p->left&&p->flags!=ASSIGNADD){ struct struct_declaration *sd;
/* bei ASSIGNADD wird der linke Zweig durch den Link bewertet */
ok&=type_expression2(p->left); p->sidefx|=p->left->sidefx;
if(!ok) return(0);
}
if(p->right&&p->right->flags!=MEMBER){ struct struct_declaration *sd;
if(p->flags==ASSIGNADD) dontopt=1; else dontopt=0;
ok&=type_expression2(p->right); p->sidefx|=p->right->sidefx;
if(!ok) return(0);
}
/* printf("bearbeite %s\n",ename[p->flags]);*/
/* Erzeugung von Zeigern aus Arrays */
/* Hier muss noch einiges genauer werden (wie gehoert das?) */
if(p->left&&((p->left->ntyp->flags&NQ)==ARRAY||(p->left->ntyp->flags&NQ)==FUNKT)){
if(f!=ADDRESS&&f!=ADDRESSA&&f!=ADDRESSS&&f!=FIRSTELEMENT&&f!=DSTRUCT&&(f<PREINC||f>POSTDEC)&&(f<ASSIGN||f>ASSIGNRSHIFT)){
np new=mymalloc(NODES);
if((p->left->ntyp->flags&NQ)==ARRAY) new->flags=ADDRESSA;
else new->flags=ADDRESS;
new->ntyp=0;
new->left=p->left;
new->right=0;new->lvalue=0;new->sidefx=0; /* sind sidefx immer 0? */
p->left=new;
ok&=type_expression2(p->left);
}
}
if(p->right&&f!=FIRSTELEMENT&&f!=DSTRUCT&&f!=ADDRESSS&&((p->right->ntyp->flags&NQ)==ARRAY||(p->right->ntyp->flags&NQ)==FUNKT)){
np new=mymalloc(NODES);
if((p->right->ntyp->flags&NQ)==ARRAY) new->flags=ADDRESSA;
else new->flags=ADDRESS;
new->ntyp=0;
new->left=p->right;
new->right=0;new->lvalue=0;new->sidefx=0; /* sind sidefx immer 0? */
p->right=new;
ok&=type_expression2(p->right);
}
if(f==IDENTIFIER||f==(IDENTIFIER|256)){
int ff;struct Var *v;
v=find_var(p->identifier,0);
if(v==0){error(82,p->identifier);return(0);}
ff=v->vtyp->flags&NQ;
if((ff>=CHAR&&ff<=DOUBLE)||ff==POINTER||ff==STRUCT||ff==UNION/*||ff==ARRAY*/) p->lvalue=1;
p->ntyp=clone_typ(v->vtyp);
/* arithmetischen const Typ als Konstante behandeln, das muss noch
deutlich anders werden, bevor man es wirklich so machen kann
if((p->ntyp->flags&CONST)&&arith(p->ntyp->flags&NQ)&&v->clist&&!(f&256)){
p->flags=CEXPR;
p->val=v->clist->val;
v->flags|=USEDASSOURCE;
}*/
p->flags&=~256;
if((p->ntyp->flags&NQ)==ENUM){
/* enumerations auch als Konstante (int) behandeln */
p->flags=CEXPR;
if(!v->clist) ierror(0);
p->val=v->clist->val;
p->ntyp->flags=CONST|INT;
}
p->o.v=v;
return(1);
}
if(f==CEXPR||f==PCEXPR||f==STRING) return(1);
if(f==KOMMA){
p->ntyp=clone_typ(p->right->ntyp);
if(f==CEXPR) p->val=p->right->val;
return(ok);
}
if(f==ASSIGN||f==ASSIGNADD){
if(!p){ierror(0);return(0);}
if(!p->left){ierror(0);return(0);}
if(p->left->lvalue==0) {error(86);/*prd(p->left->ntyp);*/return(0);}
if(const_typ(p->left->ntyp)) {error(87);return(0);}
if(type_uncomplete(p->left->ntyp)) {error(88);return(0);}
if(type_uncomplete(p->right->ntyp)) {error(88);return(0);}
p->ntyp=clone_typ(p->left->ntyp);
p->sidefx=1;
return(test_assignment(p->left->ntyp,p->right));
}
if(f==LOR||f==LAND){
int a1=-1,a2=-1,m;
if(f==LAND) m=1; else m=0;
p->ntyp=mymalloc(TYPS);
p->ntyp->flags=INT;p->ntyp->next=0;
if(!arith(p->left->ntyp->flags&NQ)&&(p->left->ntyp->flags&NQ)!=POINTER)
{error(89);ok=0;}
if(!arith(p->right->ntyp->flags&NQ)&&(p->right->ntyp->flags&NQ)!=POINTER)
{error(89);ok=0;}
if(p->left->flags==CEXPR){
eval_constn(p->left);
if(!zdeqto(vdouble,d2zd(0.0))||!zuleqto(vulong,ul2zul(0UL))||!zleqto(vlong,l2zl(0L))) a1=1; else a1=0;
}
if(p->right->flags==CEXPR){
eval_constn(p->right);
if(!zdeqto(vdouble,d2zd(0.0))||!zuleqto(vulong,ul2zul(0UL))||!zleqto(vlong,l2zl(0L))) a2=1; else a2=0;
}
if(a1==1-m||a2==1-m||(a1==m&&a2==m)){
p->flags=CEXPR;p->sidefx=0;
if(!p->left->sidefx) {free_expression(p->left);p->left=0;} else p->sidefx=1;
if(!p->right->sidefx||a1==1-m) {free_expression(p->right);p->right=0;} else p->sidefx=0;
if(a1==1-m||a2==1-m) {p->val.vint=zl2zi(l2zl((long)(1-m)));}
else {p->val.vint=zl2zi(l2zl((long)m));}
}
return(ok);
}
if(f==OR||f==AND||f==XOR){
if(((p->left->ntyp->flags&NQ)<CHAR)||((p->left->ntyp->flags&NQ)>LONG)){error(90);return(0);}
if(((p->right->ntyp->flags&NQ)<CHAR)||((p->right->ntyp->flags&NQ)>LONG)){error(90);return(0);}
p->ntyp=arith_typ(p->left->ntyp,p->right->ntyp);
if(!mopt){
if(!alg_opt(p)) ierror(0);
}
return(ok);
}
if(f==LESS||f==LESSEQ||f==GREATER||f==GREATEREQ||f==EQUAL||f==INEQUAL){
/* hier noch einige Abfragen fuer sichere Entscheidungen einbauen */
/* z.B. unigned/signed-Vergleiche etc. */
/* die val.vint=0/1-Zuweisungen muessen noch an zint angepasst */
/* werden */
zlong s1,s2;zulong u1,u2;zdouble d1,d2;int c=0;
struct Typ *t;
if(!arith(p->left->ntyp->flags&NQ)||!arith(p->right->ntyp->flags&NQ)){
if((p->left->ntyp->flags&NQ)!=POINTER||(p->right->ntyp->flags&NQ)!=POINTER){
if(f!=EQUAL&&f!=INEQUAL){
error(92);return(0);
}else{
if(((p->left->ntyp->flags&NQ)!=POINTER||p->right->flags!=CEXPR)&&
((p->right->ntyp->flags&NQ)!=POINTER||p->left->flags!=CEXPR)){
error(93);return(0);
}else{
if(p->left->flags==CEXPR) eval_constn(p->left);
else eval_constn(p->right);
if(!zdeqto(vdouble,d2zd(0.0))||!zleqto(vlong,l2zl(0L))||!zuleqto(vulong,ul2zul(0UL)))
{error(40);return(0);}
}
}
}else{
if(compare_pointers(p->left->ntyp->next,p->right->ntyp->next,NQ)){
}else{
if(f!=EQUAL&&f!=INEQUAL){error(41);}
if((p->left->ntyp->next->flags&NQ)!=VOID&&(p->right->ntyp->next->flags&NQ)!=VOID)
{error(41);}
}
}
}
if(p->left->flags==CEXPR){
eval_constn(p->left);
d1=vdouble;u1=vulong;s1=vlong;c|=1;
if(p->right->ntyp->flags&UNSIGNED&&!(p->left->ntyp->flags&UNSIGNED)){
if(zdleq(d1,zl2zd(l2zl(0)))&&zlleq(s1,l2zl(0))){
if(!zdeqto(d1,d2zd(0.0))||!zleqto(s1,l2zl(0L))){
error(165);
}else{
if(f==GREATER||f==LESSEQ) error(165);
}
}
}
}
if(p->right->flags==CEXPR){
eval_constn(p->right);
d2=vdouble;u2=vulong;s2=vlong;c|=2;
if(p->left->ntyp->flags&UNSIGNED&&!(p->right->ntyp->flags&UNSIGNED)){
if(zdleq(d2,zl2zd(l2zl(0)))&&zlleq(s2,l2zl(0))){
if(!zdeqto(d2,d2zd(0.0))||!zleqto(s2,l2zl(0L))){
error(165);
}else{
if(f==LESS||f==GREATEREQ) error(165);
}
}
}
}
p->ntyp=mymalloc(TYPS);
p->ntyp->flags=INT;
p->ntyp->next=0;
if(c==3){
p->flags=CEXPR;
t=arith_typ(p->left->ntyp,p->right->ntyp);
if(!p->left->sidefx) {free_expression(p->left);p->left=0;}
if(!p->right->sidefx) {free_expression(p->right);p->right=0;}
if((t->flags&NQ)==FLOAT||(t->flags&NQ)==DOUBLE){
if(f==EQUAL) p->val.vint=zdeqto(d1,d2);
if(f==INEQUAL) p->val.vint=!zdeqto(d1,d2);
if(f==LESSEQ) p->val.vint=zdleq(d1,d2);
if(f==GREATER) p->val.vint=!zdleq(d1,d2);
if(f==LESS){
if(zdleq(d1,d2)&&!zdeqto(d1,d2)) p->val.vint=1;
else p->val.vint=0;
}
if(f==GREATEREQ){
if(!zdleq(d1,d2)||zdeqto(d1,d2)) p->val.vint=1;
else p->val.vint=0;
}
}else{
if(t->flags&UNSIGNED){
if(f==EQUAL) p->val.vint=zuleqto(u1,u2);
if(f==INEQUAL) p->val.vint=!zuleqto(u1,u2);
if(f==LESSEQ) p->val.vint=zulleq(u1,u2);
if(f==GREATER) p->val.vint=!zulleq(u1,u2);
if(f==LESS){
if(zulleq(u1,u2)&&!zuleqto(u1,u2)) p->val.vint=1;
else p->val.vint=0;
}
if(f==GREATEREQ){
if(!zulleq(u1,u2)||zuleqto(u1,u2)) p->val.vint=1;
else p->val.vint=0;
}
}else{
if(f==EQUAL) p->val.vint=zleqto(s1,s2);
if(f==INEQUAL) p->val.vint=!zleqto(s1,s2);
if(f==LESSEQ) p->val.vint=zlleq(s1,s2);
if(f==GREATER) p->val.vint=!zlleq(s1,s2);
if(f==LESS){
if(zlleq(s1,s2)&&!zleqto(s1,s2)) p->val.vint=1;
else p->val.vint=0;
}
if(f==GREATEREQ){
if(!zlleq(s1,s2)||zleqto(s1,s2)) p->val.vint=1;
else p->val.vint=0;
}
}
}
freetyp(t);
}
return(ok);
}
if(f==ADD||f==SUB||f==MULT||f==DIV||f==MOD||f==LSHIFT||f==RSHIFT||f==PMULT){
if(!arith(p->left->ntyp->flags&NQ)||!arith(p->right->ntyp->flags&NQ)){
np new;zlong sz; int type=0;
if(f!=ADD&&f!=SUB){error(94);return(0);}
if((p->left->ntyp->flags&NQ)==POINTER){
if((p->left->ntyp->next->flags&NQ)==VOID)
{error(95);return(0);}
if((p->right->ntyp->flags&NQ)==POINTER){
if((p->right->ntyp->next->flags&NQ)==VOID)
{error(95);return(0);}
if(!compare_pointers(p->left->ntyp->next,p->right->ntyp->next,NQ))
{error(41);}
if(f!=SUB){error(96);return(0);}
else {type=3;}
}else{
if((p->right->ntyp->flags&NQ)>LONG)
{error(97,ename[f]);return(0);}
if((p->right->ntyp->flags&NQ)<CHAR)
{error(97,ename[f]);return(0);}
if(p->right->flags!=PMULT&&p->right->flags!=PCEXPR){
new=mymalloc(NODES);
new->flags=PMULT;
new->ntyp=0;
new->left=p->right;
new->right=mymalloc(NODES);
new->right->flags=PCEXPR;
new->right->left=new->right->right=0;
new->right->ntyp=mymalloc(TYPS);
new->right->ntyp->flags=INT;
new->right->ntyp->next=0;
sz=szof(p->left->ntyp->next);
if(zleqto(l2zl(0L),sz)) error(78);
new->right->val.vint=zl2zi(sz);
p->right=new;
ok&=type_expression2(p->right);
}
type=1;
}
}else{
np merk;
if((p->right->ntyp->flags&NQ)!=POINTER)
{error(98);return(0);}
if((p->right->ntyp->next->flags&NQ)==VOID)
{error(95);return(0);}
if((p->left->ntyp->flags&NQ)>LONG)
{error(98);return(0);}
if((p->left->ntyp->flags&NQ)<CHAR)
{error(98);return(0);}
if(p->flags==SUB){error(99);return(0);}
if(p->left->flags!=PMULT&&p->left->flags!=PCEXPR){
new=mymalloc(NODES);
new->flags=PMULT;
new->ntyp=0;
new->left=p->left;
new->right=mymalloc(NODES);
new->right->flags=PCEXPR;
new->right->left=new->right->right=0;
new->right->ntyp=mymalloc(TYPS);
new->right->ntyp->flags=INT;
new->right->ntyp->next=0;
sz=szof(p->right->ntyp->next);
if(zleqto(l2zl(0L),sz)) error(78);
new->right->val.vint=zl2zi(sz);
p->left=new;
ok&=type_expression2(p->left);
}
type=2;
merk=p->left;p->left=p->right;p->right=merk;
}
if(type==0){ierror(0);return(0);}
else{
if(type==3){
p->ntyp=mymalloc(TYPS);
p->ntyp->next=0;p->ntyp->flags=INT;
}else{
/*if(type==1)*/ p->ntyp=clone_typ(p->left->ntyp);
/* else p->ntyp=clone_typ(p->right->ntyp);*/
/* Abfrage wegen Vertauschen der Knoten unnoetig */
}
}
}else{
p->ntyp=arith_typ(p->left->ntyp,p->right->ntyp);
if((p->ntyp->flags&NQ)>LONG&&(f==MOD||f==LSHIFT||f==RSHIFT))
{error(101);ok=0;}
/* Typerweiterungen fuer SHIFTS korrigieren */
if((f==LSHIFT||f==RSHIFT)&&(p->ntyp->flags&NQ)==LONG&&(p->left->ntyp->flags&NQ)<LONG)
{p->ntyp->flags&=~NQ;p->ntyp->flags|=INT;}
}
/* fuegt &a+x zusammen, noch sub und left<->right machen */
/* Bei CEXPR statt PCEXPR auch machen? */
if((p->flags==ADD||p->flags==SUB)){
np m,c=0,a=0;
if(p->left->flags==PCEXPR&&p->flags==ADD) c=p->left;
if(p->right->flags==PCEXPR) c=p->right;
if(p->left->flags==ADDRESS||p->left->flags==ADDRESSA||p->left->flags==ADDRESSS) a=p->left;
if(p->right->flags==ADDRESS||p->right->flags==ADDRESSA||p->right->flags==ADDRESSS) a=p->right;
if(c&&a){
m=a->left;
/* kann man das hier so machen oder muss man da mehr testen ? */
while(m->flags==FIRSTELEMENT||m->flags==ADDRESS||m->flags==ADDRESSA||m->flags==ADDRESSS) m=m->left;
if(m->flags==IDENTIFIER){
if(DEBUG&1) printf("&a+x with %s combined\n",ename[p->left->flags]);
eval_const(&c->val,c->ntyp->flags);
if(p->flags==ADD) m->val.vlong=zuladd(m->val.vlong,vlong);
else m->val.vlong=zlsub(m->val.vlong,vlong);
vlong=szof(m->ntyp);
if(!zleqto(vlong,l2zl(0L))&&zulleq(vlong,m->val.vlong)){
if(zuleqto(vlong,m->val.vlong))
error(79);
else
error(80);
}
vlong=l2zl(0L);
if(!zleqto(m->val.vlong,l2zl(0L))&&zulleq(m->val.vlong,vlong)) error(80);
free_expression(c);
if(p->ntyp) freetyp(p->ntyp);
*p=*a;
free(a);
return(type_expression2(p));
}
}
}
if(!mopt){
if(!alg_opt(p)) ierror(0);
}
return(ok);
}
if(f==CAST){
int from=p->left->ntyp->flags&NQ,to=p->ntyp->flags&NQ;
if(to==VOID) return(ok);
if(from==VOID)
{error(102);return(0);}
if((!arith(to)||!arith(from))&&
(to!=POINTER||from!=POINTER)){
if(to==POINTER){
if(from<=LONG){
if(!zlleq(sizetab[from],sizetab[POINTER])){
error(103);return(0);
}
}else{
error(104);return(0);
}
}else{
if(from!=POINTER)
{error(105);return(0);}
if(to<=LONG){
if(!zlleq(sizetab[POINTER],sizetab[to])){
error(106);return(0);
}
}else{
error(104);return(0);
}
}
}
if(from<=LONG&&to<=LONG&&!zlleq(sizetab[from],sizetab[to])&&p->left->flags!=CEXPR) error(166);
if(to==POINTER&&from==POINTER&&!zlleq(falign(p->ntyp->next),falign(p->left->ntyp->next)))
error(167);
if(p->left->flags==CEXPR){
eval_constn(p->left);
if((p->ntyp->flags&NQ)==POINTER)
if(!zuleqto(vulong,ul2zul(0UL))||!zleqto(vlong,l2zl(0L))||!zdeqto(vdouble,d2zd(0.0)))
error(81);
insert_const(p);
p->flags=CEXPR;
if(!p->left->sidefx) {free_expression(p->left);p->left=0;}
}
return(ok);
}
if(f==MINUS||f==KOMPLEMENT||f==NEGATION){
if(!arith(p->left->ntyp->flags&NQ)){
if(f!=NEGATION){error(107);return(0);
}else{
if((p->left->ntyp->flags&NQ)!=POINTER)
{error(108);return(0);}
}
}
if(f==KOMPLEMENT&&(p->left->ntyp->flags&NQ)>LONG)
{error(109);return(0);}
if(f==NEGATION){
p->ntyp=mymalloc(TYPS);
p->ntyp->next=0;
p->ntyp->flags=INT;
}else{
if(!p->left->ntyp) ierror(0);
p->ntyp=clone_typ(p->left->ntyp);
if((p->ntyp->flags&NQ)<=LONG) p->ntyp->flags=int_erw(p->ntyp->flags);
}
if(p->left->flags==CEXPR){
eval_constn(p->left);
if(f==KOMPLEMENT){vlong=zlkompl(vlong);vulong=zlkompl(vulong);
vint=zl2zi(vlong);vuint=zul2zui(vulong);}
if(f==MINUS){vdouble=zdsub(d2zd(0.0),vdouble);vfloat=zd2zf(vdouble);
vulong=zulsub(ul2zul(0UL),vulong);vuint=zul2zui(vulong);
vlong=zlsub(l2zl(0L),vlong);vint=zl2zi(vlong);}
if(f==NEGATION){if(zdeqto(vdouble,d2zd(0.0))&&zuleqto(vulong,ul2zul(0UL))&&zleqto(vlong,l2zl(0L)))
vlong=l2zl(1L); else vlong=l2zl(0L);
vint=zl2zi(vlong);
}
insert_const(p);
p->flags=CEXPR;
if(!p->left->sidefx&&p->left) {free_expression(p->left);p->left=0;}
}
return(ok);
}
if(f==CONTENT){
if((p->left->ntyp->flags&NQ)!=POINTER)
{error(111);return(0);}
if((p->left->ntyp->next->flags&NQ)!=ARRAY&&type_uncomplete(p->left->ntyp->next))
{error(112);return(0);}
p->ntyp=clone_typ(p->left->ntyp->next);
if((p->ntyp->flags&NQ)!=ARRAY) p->lvalue=1;
if(p->left->flags==ADDRESS&&zuleqto(p->left->val.vulong,ul2zul(0UL))){
/* *&x durch x ersetzen */
np merk;
merk=p->left;
if(p->ntyp) freetyp(p->ntyp);
if(p->left->ntyp) freetyp(p->left->ntyp);
*p=*p->left->left;
free(merk->left);
free(merk);
return(ok);
}
/* *&ax durch firstelement-of(x) ersetzen */
if(p->left->flags==ADDRESSA||p->left->flags==ADDRESSS){
np merk;
if(DEBUG&1) printf("substitutet * and %s with FIRSTELEMENT\n",ename[p->left->flags]);
p->flags=FIRSTELEMENT;
p->lvalue=1; /* evtl. hier erst Abfrage ? */
merk=p->left;
p->left=merk->left;
p->right=merk->right;
if(merk->ntyp) freetyp(merk->ntyp);
free(merk);
}
return(ok);
}
if(f==FIRSTELEMENT){
/* if((p->left->ntyp->flags&NQ)!=ARRAY)
{ierror(0);return(0);}*/
if((p->left->ntyp->flags&NQ)==ARRAY) p->ntyp=clone_typ(p->left->ntyp->next);
else{
int i,n=-1;
for(i=0;i<p->left->ntyp->exact->count;i++)
if(!strcmp((*p->left->ntyp->exact->sl)[i].identifier,p->right->identifier)) n=i;
if(n<0){ierror(0);return(0);}
p->ntyp=clone_typ((*p->left->ntyp->exact->sl)[n].styp);
}
p->lvalue=1; /* hier noch genauer testen ? */
return(ok);
}
if(f==ADDRESS){
if((p->left->ntyp->flags&NQ)!=FUNKT&&(p->left->ntyp->flags&NQ)!=ARRAY){
if(!p->left->lvalue){error(115);return(0);}
if(p->left->flags==IDENTIFIER){
struct Var *v;
v=find_var(p->left->identifier,0);
if(!v){error(116,p->left->identifier);return(0);}
if(v->storage_class==REGISTER)
{error(117);return(0);}
}
}
p->ntyp=mymalloc(TYPS);
p->ntyp->flags=POINTER;
p->ntyp->next=clone_typ(p->left->ntyp);
return(ok);
}
if(f==ADDRESSA){
p->ntyp=clone_typ(p->left->ntyp);
p->ntyp->flags=POINTER;
return(ok);
}
if(f==ADDRESSS){
int i,n=-1;
for(i=0;i<p->left->ntyp->exact->count;i++)
if(!strcmp((*p->left->ntyp->exact->sl)[i].identifier,p->right->identifier)) n=i;
if(n<0){ierror(0);return(0);}
p->ntyp=mymalloc(TYPS);
p->ntyp->flags=POINTER;
if(!p->left->ntyp) ierror(0);
if(!p->left->ntyp->exact) ierror(0);
if(!(*p->left->ntyp->exact->sl)[n].styp) ierror(0);
p->ntyp->next=clone_typ((*p->left->ntyp->exact->sl)[n].styp);
return(ok);
}
if(f==DSTRUCT){
/* hier kann man bei unions einiges schneller/einfacher machen */
int i=0,f;struct Typ *t;np new;zlong offset=l2zl(0L),al;
if((p->left->ntyp->flags&NQ)!=STRUCT&&(p->left->ntyp->flags&NQ)!=UNION)
{error(8);return(0);}
if(type_uncomplete(p->left->ntyp)){error(11);return(0);}
if(p->right->flags!=MEMBER)
{ierror(0);return(0);}
while(i<p->left->ntyp->exact->count&&strcmp((*p->left->ntyp->exact->sl)[i].identifier,p->right->identifier)){
t=(*p->left->ntyp->exact->sl)[i].styp;
al=falign(t);
offset=zlmult(zldiv(zladd(offset,zlsub(al,l2zl(1L))),al),al);
offset=zladd(offset,szof(t));
i++;
}
if(i>=p->left->ntyp->exact->count) {error(23,p->right->identifier);return(0);}
t=(*p->left->ntyp->exact->sl)[i].styp;
al=falign(t);
offset=zlmult(zldiv(zladd(offset,zlsub(al,l2zl(1L))),al),al);
if((p->left->ntyp->flags&NQ)==UNION) offset=l2zl(0L);
p->flags=CONTENT;if(p->ntyp) {freetyp(p->ntyp);p->ntyp=0;}
new=mymalloc(NODES);
new->flags=ADD;
new->ntyp=0;
new->right=mymalloc(NODES);
new->right->left=new->right->right=0;
new->right->flags=PCEXPR;
new->right->ntyp=mymalloc(TYPS);
new->right->ntyp->flags=LONG;
new->right->ntyp->next=0;
new->right->val.vlong=offset;
new->left=mymalloc(NODES);
new->left->flags=ADDRESSS;
new->left->left=p->left;
new->left->right=p->right;
new->left->ntyp=0;
p->left=new;p->right=0;
return(type_expression2(p));
}
if(f==PREINC||f==POSTINC||f==PREDEC||f==POSTDEC){
if(!p->left->lvalue){error(86);return(0);}
if(p->left->ntyp->flags&CONST){error(87);return(0);}
if(!arith(p->left->ntyp->flags&NQ)){
if((p->left->ntyp->flags&NQ)!=POINTER){
error(24);return(0);
}else{
if((p->left->ntyp->next->flags&NQ)==VOID)
{error(95);return(0);}
}
}
p->ntyp=clone_typ(p->left->ntyp);
p->sidefx=1;
return(ok);
}
if(f==CALL){
struct argument_list *al;int i,flags=0;char *s=0;
struct struct_declaration *sd;
al=p->alist;
if((p->left->ntyp->flags&NQ)!=POINTER||(p->left->ntyp->next->flags&NQ)!=FUNKT)
{error(26);return(0);}
if(ok&&p->left->left&&p->left->left->flags==IDENTIFIER&&p->left->left->o.v->storage_class==EXTERN){
s=p->left->left->o.v->identifier;
flags=p->left->left->o.v->flags;
}
sd=p->left->ntyp->next->exact;
if(!sd){ierror(0);return(0);}
if(sd->count==0){
error(162);
if(s){
if(!strcmp(s,"printf")||!strcmp(s,"fprintf")||!strcmp(s,"sprintf")||
!strcmp(s,"scanf")|| !strcmp(s,"fscanf")|| !strcmp(s,"sscanf"))
error(213);
}
}
while(al){
if(!al->arg) ierror(0);
if(!type_expression2(al->arg)) return(0);
al->arg=makepointer(al->arg);
if(type_uncomplete(al->arg->ntyp)) error(39);
al=al->next;
}
p->sidefx=1;
p->ntyp=clone_typ(p->left->ntyp->next->next);
i=0;al=p->alist;
while(al){
if(i>=sd->count) return(ok);
if(!(*sd->sl)[i].styp) return(ok); /* nur Bezeichner, aber kein Typ im Prototype */
if(!test_assignment((*sd->sl)[i].styp,al->arg)) return(0);
if(i==sd->count-1&&(flags&(PRINTFLIKE|SCANFLIKE))){
if(al->arg->left&&al->arg->left->flags==STRING){
/* Argumente anhand des Formatstrings ueberpruefen */
struct const_list *cl=al->arg->left->cl;
int fused=0;
al=al->next;
while(cl&&cl->other){
int c,fflags=' ',at;
struct Typ *t;
c=(int)zul2zl(zuc2zul(cl->other->val.vchar));
cl=cl->next;
if(c==0){
if(cl) error(215);
break;
}
if(c!='%') continue;
if(!cl){error(214);return(ok);}
c=(int)zul2zl(zuc2zul(cl->other->val.vchar));
cl=cl->next;
while(isdigit((unsigned char)c)||
c=='-'||c=='+'||c==' '||c=='#'||c=='.'||
c=='h'||c=='l'||c=='L'||c=='*'){
fused|=3;
if(c=='*'&&(flags&PRINTFLIKE)){
if(!al) {error(214);return(ok);}
at=al->arg->ntyp->flags&NQ;
al=al->next;
if(at>INT) {error(214);return(ok);}
}
if((fflags!='*'||(flags&PRINTFLIKE))&&(c=='h'||c=='l'||c=='L'||c=='*'))
fflags=c;
c=(int)zul2zl(zuc2zul(cl->other->val.vchar));
cl=cl->next;
if(!cl){error(214);return(ok);}
}
if(DEBUG&1) printf("format=%c%c\n",fflags,c);
if(fflags=='*'&&(flags&SCANFLIKE)) continue;
if(c!='%'){
if(!al){error(214);return(ok);}
t=al->arg->ntyp;
if(DEBUG&1){ prd(stdout,t);printf("\n");}
if((flags&SCANFLIKE)){
if((t->flags&NQ)!=POINTER){error(214);return(ok);}
t=t->next;
}
at=t->flags&NU;
}
if(flags&PRINTFLIKE){
switch(c){
case '%':
fused|=1;
break;
case 'o':
case 'x':
case 'X':
case 'c':
at&=NQ; /* fall through */
case 'i':
case 'd':
fused|=1;
if(at==LONG&&fflags!='l'){error(214);return(ok);}
if(fflags=='l'&&at!=LONG){error(214);return(ok);}
if(at<CHAR||at>LONG){error(214);return(ok);}
break;
case 'u':
fused|=1;
if(al->arg->flags==CEXPR) at|=UNSIGNED;
if(at==(UNSIGNED|LONG)&&fflags!='l'){error(214);return(ok);}
if(fflags=='l'&&at!=(UNSIGNED|LONG)){error(214);return(ok);}
if(at<(UNSIGNED|CHAR)||at>(UNSIGNED|LONG)){error(214);return(ok);}
break;
case 's':
fused|=1;
if(at!=POINTER||(t->next->flags&NQ)!=CHAR){error(214);return(ok);}
break;
case 'f':
case 'e':
case 'E':
case 'g':
case 'G':
fused|=7;
if(at!=FLOAT&&at!=DOUBLE){error(214);return(ok);}
break;
case 'p':
fused|=3;
if(at!=POINTER||(t->next->flags)!=VOID){error(214);return(ok);}
break;
case 'n':
fused|=3;
if(at!=POINTER){error(214);return(ok);}
at=t->next->flags&NU;
if(fflags=='h'&&at!=SHORT){error(214);return(ok);}
if(fflags==' '&&at!=INT){error(214);return(ok);}
if(fflags=='l'&&at!=LONG){error(214);return(ok);}
break;
default:
error(214);return(ok);
}
}else{
switch(c){
case '%':
fused|=1;
break;
case '[':
fused|=3;
do{
c=(int)zul2zl(zuc2zul(cl->other->val.vchar));
cl=cl->next;
if(!cl){error(214);return(ok);}
}while(c!=']'); /* fall through */
case 's':
case 'c':
fused|=1;
if((at&NQ)!=CHAR){error(214);return(ok);}
break;
case 'n':
fused|=3; /* fall through */
case 'd':
case 'i':
case 'o':
case 'x':
fused|=1;
if(fflags=='h'&&at!=SHORT){error(214);return(ok);}
if(fflags==' '&&at!=INT){error(214);return(ok);}
if(fflags=='l'&&at!=LONG){error(214);return(ok);}
break;
case 'u':
fused|=1;
if(fflags=='h'&&at!=(UNSIGNED|SHORT)){error(214);return(ok);}
if(fflags==' '&&at!=(UNSIGNED|INT)){error(214);return(ok);}
if(fflags=='l'&&at!=(UNSIGNED|LONG)){error(214);return(ok);}
break;
case 'e':
case 'f':
case 'g':
fused|=7;
if(fflags==' '&&at!=FLOAT){error(214);return(ok);}
if(fflags=='l'&&at!=DOUBLE){error(214);return(ok);}
if(fflags=='L'&&at!=DOUBLE){error(214);return(ok);}
break;
case 'p':
fused|=3;
if(at!=POINTER||(t->next->flags&NQ)!=VOID){error(214);return(ok);}
break;
default:
error(214);return(ok);
}
}
if(c!='%') al=al->next;
}
if(al){ error(214);return(ok);} /* zu viele */
if(DEBUG&1) printf("fused=%d\n",fused);
if(fused!=7&&s){
/* Wenn kein Format benutzt wird, kann man printf, */
/* scanf etc. durch aehnliches ersetzen. */
struct Var *v;char repl[MAXI+6]="__v";
if(fused==3) fused=2;
repl[3]=fused+'0';repl[4]=0;
strcat(repl,s);
if(DEBUG&1) printf("repl=%s\n",repl);
while(fused<=2){
v=find_var(repl,0);
if(v&&v->storage_class==EXTERN){
p->left->left->o.v=v;
break;
}
fused++;repl[3]++;
}
}
return(ok);
}
}
i++;al=al->next;
}
if(i>=sd->count) return(ok);
if((*sd->sl)[i].styp&&((*sd->sl)[i].styp->flags&NQ)!=VOID){error(83);/*printf("sd->count=%d\n",sd->count);*/}
return(ok);
}
if(f==COND){
if(!arith(p->left->ntyp->flags&NQ)&&(p->left->ntyp->flags&NQ)!=POINTER){
error(29);
return(0);
}
if(p->left->flags==CEXPR&&!p->left->sidefx){
int null;np merk;
if(DEBUG&1) printf("constant conditional-expression simplified\n");
eval_constn(p->left);
if(zleqto(vlong,l2zl(0L))&&zuleqto(vulong,ul2zul(0UL))&&zdeqto(vdouble,d2zd(0.0))) null=1; else null=0;
free_expression(p->left);
merk=p->right;
if(null){
free_expression(p->right->left);
*p=*p->right->right;
}else{
free_expression(p->right->right);
*p=*p->right->left;
}
if(merk->ntyp) freetyp(merk->ntyp);
free(merk);
return(1);
}
p->ntyp=clone_typ(p->right->ntyp);
return(1);
}
if(f==COLON){
/* Hier fehlt noch korrekte Behandlung der Typattribute */
if(arith(p->left->ntyp->flags&NQ)&&arith(p->right->ntyp->flags&NQ)){
p->ntyp=arith_typ(p->left->ntyp,p->right->ntyp);
return(1);
}
if(compare_pointers(p->left->ntyp,p->right->ntyp,NQ)){
p->ntyp=clone_typ(p->left->ntyp);
return(1);
}
if((p->left->ntyp->flags&NQ)==POINTER&&(p->right->ntyp->flags&NQ)==POINTER){
if((p->left->ntyp->next->flags&NQ)==VOID){
p->ntyp=clone_typ(p->left->ntyp);
return(1);
}
if((p->right->ntyp->next->flags&NQ)==VOID){
p->ntyp=clone_typ(p->right->ntyp);
return(1);
}
}
if((p->left->ntyp->flags&NQ)==POINTER&&p->right->flags==CEXPR){
eval_constn(p->right);
if(zleqto(vlong,l2zl(0L))&&zuleqto(ul2zul(0UL),vulong)&&zdeqto(d2zd(0.0),vdouble)){
p->ntyp=clone_typ(p->left->ntyp);
return(1);
}
}
if((p->right->ntyp->flags&NQ)==POINTER&&p->left->flags==CEXPR){
eval_constn(p->left);
if(zleqto(l2zl(0L),vlong)&&zuleqto(ul2zul(0UL),vulong)&&zdeqto(d2zd(0.0),vdouble)){
p->ntyp=clone_typ(p->right->ntyp);
return(1);
}
}
error(31);
return(0);
}
if(f) printf("type_testing fuer diesen Operator (%d) noch nicht implementiert\n",f);
return(0);
}
np makepointer(np p)
/* Fuehrt automatische Zeigererzeugung fuer Baumwurzel durch */
/* Durch mehrmaligen Aufruf von type_expression() ineffizient */
{
struct struct_declaration *sd;
if((p->ntyp->flags&NQ)==ARRAY||(p->ntyp->flags&NQ)==FUNKT){
np new=mymalloc(NODES);
if((p->ntyp->flags&NQ)==ARRAY){
new->flags=ADDRESSA;
new->ntyp=clone_typ(p->ntyp);
new->ntyp->flags=POINTER;
/* new->ntyp=0;*/
}else{
new->flags=ADDRESS;
new->ntyp=mymalloc(TYPS);
new->ntyp->flags=POINTER;
new->ntyp->next=clone_typ(p->ntyp);
/* new->ntyp=0;*/
}
new->left=p;
new->right=0;
new->lvalue=0; /* immer korrekt ? */
new->sidefx=p->sidefx;
/* type_expression(new);*/
return(new);
}else return(p);
}
int alg_opt(np p)
/* fuehrt algebraische Vereinfachungen durch */
/* hier noch genau testen, was ANSI-gemaess erlaubt ist etc. */
/* v.a. Floating-Point ist evtl. kritisch */
{
int c=0,f,komm,null1,null2,eins1,eins2;np merk;
zdouble d1,d2;zulong u1,u2;zlong s1,s2;
f=p->flags;
/* kommutativ? */
if(f==ADD||f==MULT||f==PMULT||(f>=OR&&f<=AND)) komm=1; else komm=0;
/* Berechnet Wert, wenn beides Konstanten sind */
if(p->left->flags==CEXPR||p->left->flags==PCEXPR){
eval_constn(p->left);
d1=vdouble;u1=vulong;s1=vlong;c|=1;
}
if(p->right->flags==CEXPR||p->right->flags==PCEXPR){
eval_constn(p->right);
d2=vdouble;u2=vulong;s2=vlong;c|=2;
}
if(c==3){
p->flags=CEXPR;
if(DEBUG&1) printf("did simple constant folding\n");
if(!p->left->sidefx) {free_expression(p->left);p->left=0;}
if(!p->right->sidefx) {free_expression(p->right);p->right=0;}
if(f==AND){
vulong=zuland(u1,u2);
vlong=zland(s1,s2);
}
if(f==OR){
vulong=zulor(u1,u2);
vlong=zlor(s1,s2);
}
if(f==XOR){
vulong=zulxor(u1,u2);
vlong=zlxor(s1,s2);
}
if(f==ADD){
vulong=zuladd(u1,u2);
vlong=zladd(s1,s2);
vdouble=zdadd(d1,d2);
}
if(f==SUB){
vulong=zulsub(u1,u2);
vlong=zlsub(s1,s2);
vdouble=zdsub(d1,d2);
}
if(f==MULT||f==PMULT){
vulong=zulmult(u1,u2);
vlong=zlmult(s1,s2);
vdouble=zdmult(d1,d2);
if(f==PMULT) p->flags=PCEXPR;
}
if(f==DIV){
if(zleqto(l2zl(0L),s2)&&zuleqto(ul2zul(0UL),u2)&&zdeqto(d2zd(0.0),d2)){
error(84);
vlong=l2zl(0L);vulong=zl2zul(vlong);vdouble=zl2zd(vlong);
}else{
if(!zuleqto(ul2zul(0UL),u2)) vulong=zuldiv(u1,u2);
if(!zleqto(l2zl(0L),s2)) vlong=zldiv(s1,s2);
if(!zdeqto(d2zd(0.0),d2)) vdouble=zddiv(d1,d2);
}
}
if(f==MOD){
if(zleqto(l2zl(0L),s2)&&zuleqto(ul2zul(0UL),u2)){
error(84);
vlong=l2zl(0L);vulong=zl2zul(vlong);
}else{
if(!zuleqto(ul2zul(0UL),u2)) vulong=zulmod(u1,u2);
if(!zleqto(l2zl(0L),s2)) vlong=zlmod(s1,s2);
}
}
if(f==LSHIFT){
vulong=zullshift(u1,u2);
vlong=zllshift(s1,s2);
}
if(f==RSHIFT){
vulong=zulrshift(u1,u2);
vlong=zlrshift(s1,s2);
}
vuint=zul2zui(vulong);vint=zl2zi(vlong);vfloat=zd2zf(vdouble);
insert_const(p);
return(1);
}
/* Konstanten nach rechts, wenn moeglich */
if(c==1&&komm){
if(DEBUG&1) printf("exchanged commutative constant operand\n");
merk=p->left;p->left=p->right;p->right=merk;
c=2;
d2=d1;u2=u1;s2=s1;
}
/* Vertauscht die Knoten, um Konstanten */
/* besser zusammenzufassen (bei allen Type erlaubt?) */
/* Hier muss noch einiges kontrolliert werden */
if(komm&&c==2&&p->flags==p->left->flags){
if(p->left->right->flags==CEXPR||p->left->right->flags==PCEXPR){
np merk;
merk=p->right;p->right=p->left->left;p->left->left=merk;
if(DEBUG&1) printf("Vertausche Add-Nodes\n");
return(type_expression(p));
}
}
null1=null2=eins1=eins2=0;
if(c&1){
if(zdeqto(d1,d2zd(0.0))&&zuleqto(u1,ul2zul(0UL))&&zleqto(s1,l2zl(0L))) null1=1;
if(zdeqto(d1,d2zd(1.0))&&zuleqto(u1,ul2zul(1UL))&&zleqto(s1,l2zl(1L))) eins1=1;
if(!(p->ntyp->flags&UNSIGNED)&&zdeqto(d1,d2zd(-1.0))&&zleqto(s1,l2zl(-1L))) eins1=-1;
}
if(c&2){
if(zdeqto(d2,d2zd(0.0))&&zuleqto(u2,ul2zul(0UL))&&zleqto(s2,l2zl(0L))) null2=1;
if(zdeqto(d2,d2zd(1.0))&&zuleqto(u2,ul2zul(1UL))&&zleqto(s2,l2zl(1L))) eins2=1;
if(!(p->ntyp->flags&UNSIGNED)&&zdeqto(d2,d2zd(-1.0))&&zleqto(s2,l2zl(-1L))) eins2=-1;
}
if(c==2){
/* a+0=a-0=a^0=a>>0=a<<0=a*1=a/1=a */
if(((eins2==1&&(f==MULT||f==PMULT||f==DIV))||(null2&&(f==ADD||f==SUB||f==OR||f==XOR||f==LSHIFT||f==RSHIFT)))&&!p->right->sidefx){
if(DEBUG&1){if(f==MULT||f==PMULT||f==DIV) printf("a*/1->a\n"); else printf("a+-^0->a\n");}
free_expression(p->right);
merk=p->left;
*p=*p->left;
/* freetyp(merk->ntyp); das war Fehler */
free(merk);
return(type_expression(p));
}
/* a*0=0 */
if(null2&&(f==MULT||f==PMULT||f==AND||f==DIV||f==MOD)){
if(DEBUG&1) printf("a*&/%%0->0\n");
if(null2&&(f==DIV||f==MOD)) error(84);
if(p->flags==PMULT) p->flags=PCEXPR; else p->flags=CEXPR;
/* hier nur int,long,float,double moeglich, hoffe ich */
vlong=l2zl(0L);vulong=zl2zul(vlong);
vint=zl2zi(vlong);vuint=zul2zui(vulong);
vdouble=zl2zd(vlong);vfloat=zd2zf(vdouble);
insert_const(p);
if(!p->left->sidefx){free_expression(p->left);p->left=0;} else make_cexpr(p->left);
if(!p->right->sidefx){free_expression(p->right);p->right=0;} else make_cexpr(p->right);
/* return(type_expression(p)); */
return(1);
}
if(eins2==-1&&(f==MULT||f==PMULT||f==DIV)&&!p->right->sidefx){
if(DEBUG&1) printf("a*/(-1)->-a\n");
free_expression(p->right);
p->right=0;
p->flags=MINUS;
return(type_expression(p));
}
}
if(c==1){
/* 0-a=-a */
if(((f==DIV&&eins1==-1)||(f==SUB&&null1))&&!p->left->sidefx){
if(DEBUG&1){if(f==DIV) printf("-1/a->-a\n"); else printf("0-a->-a\n");}
free_expression(p->left);
p->flags=MINUS;
p->left=p->right;
p->right=0;
return(type_expression(p));
}
/* 0/a=0 */
if(null1&&(f==DIV||f==MOD||f==LSHIFT||f==RSHIFT)){
if(DEBUG&1) printf("0/%%<<>>a->0\n");
p->flags=CEXPR;
/* fier nur int,long,float,double moeglich, hoffe ich */
vlong=l2zl(0L);vulong=zl2zul(vlong);
vint=zl2zi(vlong);vuint=zul2zui(vulong);
vdouble=zl2zd(vlong);vfloat=zd2zf(vdouble);
insert_const(p);
if(!p->left->sidefx){free_expression(p->left);p->left=0;}else make_cexpr(p->left);
if(!p->right->sidefx){free_expression(p->right);p->right=0;} else make_cexpr(p->right);
return(type_expression(p));
}
}
return(1);
}
void make_cexpr(np p)
/* Macht aus einem Knoten, der durch constant-folding ueberfluessig */
/* wurde, eine PCEXPR, sofern er keine Nebenwirkungen von sich aus */
/* erzeugt. Hier noch ueberpruefen, ob CEXPR besser waere. */
/* Fuehrt rekursiven Abstieg durch. Ist das so korrekt? */
{
int f=p->flags;
if(f!=ASSIGN&&f!=ASSIGNADD&&f!=CALL&&f!=POSTINC&&f!=POSTDEC&&f!=PREINC&&f!=PREDEC){
p->flags=PCEXPR;
if(p->left) make_cexpr(p->left);
if(p->right) make_cexpr(p->right);
}
}
int test_assignment(struct Typ *zt,np q)
/* testet, ob q an Typ z zugewiesen werden darf */
{
struct Typ *qt=q->ntyp;
if(arith(zt->flags&NQ)&&arith(qt->flags&NQ)){
if((zt->flags&NQ)<=LONG&&(qt->flags&NQ)<=LONG&&
!zlleq(sizetab[qt->flags&NQ],sizetab[zt->flags&NQ])&&q->flags!=CEXPR)
error(166);
return(1);
}
if(((zt->flags&NQ)==STRUCT&&(qt->flags&NQ)==STRUCT)||
((zt->flags&NQ)==UNION &&(qt->flags&NQ)==UNION )){
if(!compare_pointers(zt,qt,255)){
error(38);return(0);}
else return(1);
}
if((zt->flags&NQ)==POINTER&&(qt->flags&NQ)==POINTER){
if((zt->next->flags&NQ)==VOID&&(qt->next->flags&NQ)!=FUNKT) return(1);
if((qt->next->flags&NQ)==VOID&&(qt->next->flags&NQ)!=FUNKT) return(1);
if(!compare_pointers(zt->next,qt->next,(c_flags[7]&USEDFLAG)?NU:NQ)){
error(85);
}else{
if((qt->next->flags&CONST)&&!(zt->next->flags&CONST))
error(91);
if((qt->next->flags&VOLATILE)&&!(zt->next->flags&VOLATILE))
error(100);
if(qt->next->next&&zt->next->next&&!compare_pointers(zt->next->next,qt->next->next,255))
error(110);
}
return(1);
}
if((zt->flags&NQ)==POINTER&&q->flags==CEXPR){
eval_constn(q);
if(!(zdeqto(d2zd(0.0),vdouble)&&zleqto(l2zl(0L),vlong)&&zuleqto(ul2zul(0UL),vulong)))
error(113);
return(1);
}
error(39);return(0);
}